home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.4d7 source / tn3270 / writetm.c < prev   
Text File  |  1992-04-17  |  15KB  |  646 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.4d7  April, 1992
  5.  *  Copyright (c) 1988, 1989, 1990, 1991, 1992 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #if !defined(USEDUMP)
  34.     #include "maclib.h"
  35.     #include "termdef.h"
  36.     #include "tn3270funcs.h"
  37.     #include "globals.h"
  38. #else
  39.     #pragma load "tn3270DumpFile"
  40. #endif
  41.  
  42. #pragma segment 3270seg1
  43.  
  44. extern unsigned char ordertab[];
  45.  
  46. void writetm(unsigned char *cmd, short len, char init, cnr *cp)
  47. {
  48. register short left;
  49. register short size;
  50. register unsigned char c, ew;
  51.  
  52. cp->savedvalid = 0;                /* getattr saved info. may be invalid now */
  53.  
  54. if (init) {
  55.     ew = 0;                        /* erase/write flag */                     
  56.     if ((cmd[0] & 0x07) >= 5) {        /* interpret op-code */
  57.         ew = 1;
  58.         if (cp->skipnewmode == 0) {
  59.             if (((cmd[0] & 0x0f) == 0x0d) || (cmd[0] == 0x7e)) {    /* ewa */
  60.                 cp->ewamode = 1;
  61.                 }
  62.             else {                        /* possible end of ewa */
  63.                 cp->ewamode = 0;
  64.                 }
  65.             newmode(cp->ewamode, 0, cp);
  66.             }
  67.         clrscn(cp);
  68.         }
  69.     intwcc(ew, cmd[1], cp);            /* interpret WCC */
  70.     cp->ldvoff = 2;                    /* skip to start of data */
  71.     cp->ptfill = 0;
  72.     cp->chratr = 0;
  73.     cp->bufadr = cp->curadr;            /* buffer address starts out at cursor */
  74.     }
  75.  
  76. while (cp->ldvoff < len) {
  77.                                 /* special code to handle data quickly */
  78.     c = cmd[cp->ldvoff++];
  79.     if (ordertab[c]) {
  80.         (cp->chrbuff)[cp->bufadr] = c;
  81.         (cp->atrbuff)[cp->bufadr] = cp->chratr;
  82.         if ((c == 0xad) || (c == 0xbd))
  83.             if (cp->fixbracket) (cp->atrbuff)[cp->bufadr] += 0x4000;
  84.         cp->bufadr++;
  85.         if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  86.         cp->ptfill = 1;
  87.         continue;
  88.         }
  89.     else cp->ldvoff--;
  90.                                 /* order processing code */
  91.     left = len - cp->ldvoff;
  92.     switch(cmd[cp->ldvoff]) {
  93.         case 0x1D:        /* Start Field */
  94.                 if (left < 2) return;
  95.                 intsf(cmd[cp->ldvoff+1], cp);
  96.                 cp->ldvoff += 2;
  97.                 cp->ptfill = 0;
  98.                 break;
  99.  
  100.         case 0x11:        /* Set Buffer Address */
  101.                 if (left < 3) return;
  102.                 intsba(cmd[cp->ldvoff+1], cmd[cp->ldvoff+2], cp);
  103.                 cp->ldvoff += 3;
  104.                 cp->ptfill = 0;
  105.                 break;
  106.  
  107.         case 0x13:        /* Insert Cursor */
  108.                 intic(cp);
  109.                 cp->ldvoff++;
  110.                 cp->ptfill = 0;
  111.                 break;
  112.  
  113.         case 0x05:        /* Program Tab */
  114.                 intpt(cp);
  115.                 cp->ldvoff++;
  116.                 break;
  117.  
  118.         case 0x3C:        /* Repeat to Address */
  119.                 if (left < 4) return;
  120.                 c = cmd[cp->ldvoff+3];
  121.                 if (c == 0x08) {
  122.                    if (left < 5) return;
  123.                    c = cmd[cp->ldvoff+4];
  124.                    intra(cmd[cp->ldvoff+1], cmd[cp->ldvoff+2], c, 1, cp);
  125.                    cp->ldvoff += 5;
  126.                    }
  127.                 else {
  128.                    intra(cmd[cp->ldvoff+1], cmd[cp->ldvoff+2], c, 0, cp);
  129.                    cp->ldvoff += 4;
  130.                    }
  131.                 cp->ptfill = 0;
  132.                 break;
  133.  
  134.         case 0x12:        /* Erase Unprotected to Address */
  135.                 if (left < 3) return;
  136.                 inteua(cmd[cp->ldvoff+1], cmd[cp->ldvoff+2], cp);
  137.                 cp->ldvoff += 3;
  138.                 cp->ptfill = 0;
  139.                 break;
  140.  
  141.         case 0x08:        /* Graphics Escape */
  142.                 if (left < 2) return;
  143.                 intdata(cmd[cp->ldvoff+1], 1, cp);
  144.                 cp->ldvoff += 2;
  145.                 break;
  146.  
  147.         case 0x29:        /* Start Field Extended */
  148.                 if (left < 2) return;
  149.                 size = (cmd[cp->ldvoff+1]+1) * 2;
  150.                 if (left < size) return;
  151.                 intsfe(cmd+cp->ldvoff+2, cmd[cp->ldvoff+1], cp);
  152.                 cp->ldvoff += size;
  153.                 cp->ptfill = 0;
  154.                 break;
  155.  
  156.         case 0x2C:        /* Modify Field */
  157.                 if (left < 2) return;
  158.                 size = (cmd[cp->ldvoff+1]+1) * 2;
  159.                 if (left < size) return;
  160.                 intmf(cmd+cp->ldvoff+2, cmd[cp->ldvoff+1], cp);
  161.                 cp->ldvoff += size;
  162.                 cp->ptfill = 0;
  163.                 break;
  164.  
  165.         case 0x28:        /* Set Attribute */
  166.                 if (left < 3)  return;
  167.                 intsa(cmd[cp->ldvoff+1], cmd[cp->ldvoff+2], cp);
  168.                 cp->ldvoff += 3;
  169.                 cp->ptfill = 0;
  170.                 break;
  171.  
  172.         default:        /* shouldn't happen */
  173.                 break;
  174.         }
  175.     }
  176. }
  177.  
  178. void clrscn(cnr *cp)
  179. {
  180. memset(cp->chrbuff, 0, cp->maxcnt);
  181. memset(cp->atrbuff, 0, cp->maxcnt<<1);
  182. cp->curadr = 0;
  183. cp->bufadr = 0;
  184. cp->colorfield = 0;
  185. cp->textsel = 0;
  186. cp->fmtscrn = 0;
  187. }
  188.  
  189. void intwcc(unsigned char ew, unsigned char wcc, cnr *cp)
  190. {
  191. register short i;
  192.  
  193. cp->lastwcc = wcc & 0x7f;
  194. if (wcc & 0x01) for (i=0; i < cp->maxcnt; i++) {
  195.     (cp->atrbuff)[i] &= 0xFEFF;
  196.     }
  197. cp->kb_err = 0;
  198. if (cp->kblock) {
  199.     cp->lastwcc |= 0x80;    /* remember was locked */
  200.                         /* indicate SYSTEM immediately */
  201.     if ((cp->kblcode == 2) && ((wcc & 0x02) == 0)) {
  202.         cp->kblcode = 1;
  203.         newstat(cp);
  204.         }
  205.     }
  206. else {
  207.     cp->kblock = 1;
  208.     cp->kblcode = 2;
  209.     newstat(cp);
  210.     }
  211. if (ew) if (wcc & 0x40)            /* wcc reset in EW/EWA */
  212.     clrpict(cp);                /* erase graphics */
  213. }
  214.  
  215. void endwcc(cnr *cp)
  216. {
  217. if (cp->lastwcc & 0x04) if (!(cp->tcpflg)) beep(cp);
  218.                         else cp->pndbeep = 1;
  219. if (cp->lastwcc & 0x02) cp->rdaid = 0x60;    /* reset last AID */
  220. if (cp->cs.curpos) {
  221.     cp->x = cp->curadr%cp->scrhsize;
  222.     cp->y = cp->curadr/cp->scrhsize;
  223.     }
  224. if ((cp->lastwcc & 0x82) != 0x80) {
  225.     cp->kblock = 0;
  226.     cp->kblcode = 0;
  227.     newstat(cp);
  228.     }
  229. else if (cp->cs.curpos) newstat(cp);
  230.  
  231. checkfmt(cp);            /* check that fmtscrn is still correct */
  232. }
  233.  
  234. void checkfmt(cnr *cp)     /* check all attributes have not been overwritten by data */
  235. {
  236. register short i;
  237.                 /* unformatted is always correct */
  238. if (cp->fmtscrn == 0) return;
  239.                 /* formatted if attribute where we last put one */
  240. if ((cp->atrbuff)[cp->attrloc] & 0x8000) return;
  241.                 /* else look for an attribute byte */
  242. for (i=0; i < cp->maxcnt; i++)
  243.     if ((cp->atrbuff)[i] & 0x8000) return;
  244.                 /* all attributes were overwritten: reset flag */
  245. cp->fmtscrn = 0;
  246. }
  247.  
  248. void intsf(unsigned char attr, cnr *cp)
  249. {
  250.  
  251. (cp->chrbuff)[cp->bufadr] = 0x1d;
  252. (cp->atrbuff)[cp->bufadr] = 0x8000 + ((attr & 0x3f) << 8);
  253. cp->attrloc = cp->bufadr;
  254. cp->bufadr++;
  255. if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  256. cp->fmtscrn = 1;
  257. }
  258.  
  259. void intsba(unsigned char a1, unsigned char a2, cnr *cp)
  260. {
  261. cp->bufadr = cvtadr(a1, a2, cp);
  262. }
  263.  
  264. void intic(cnr *cp)
  265. {
  266. cp->curadr = cp->bufadr;
  267. }
  268.  
  269. void intpt(cnr *cp)
  270. {
  271. register unsigned short a; 
  272.  
  273. while (true) {            /* loop through protected fields */
  274.     while (!((cp->atrbuff)[cp->bufadr] & 0x8000)) {    /* get to next attribute */
  275.         if (cp->ptfill) setnull(cp);        /* fill with nulls if set */
  276.         else {
  277.             cp->bufadr++;
  278.             if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  279.             }
  280.         if (cp->bufadr == 0) return;
  281.         }
  282.     cp->ptfill = 0;                    /* no nulls after first field */
  283.     a = (cp->atrbuff)[cp->bufadr];        /* get attributes for this field */
  284.     cp->bufadr++;                    /* increment buffer address */
  285.     if (cp->bufadr == cp->maxcnt) {
  286.         cp->bufadr = 0;                /* done if wrapped */
  287.         return;
  288.         }
  289.     if (!(a & 0x2000)) return;    /* found field if unprotected */
  290.     }
  291. }
  292.  
  293. void intra(unsigned char a1, unsigned char a2,
  294.            unsigned char c, unsigned char g, cnr *cp)
  295. {
  296. register short endadr;
  297.  
  298. endadr = cvtadr(a1, a2, cp);
  299. do intdata(c, g, cp); while (endadr != cp->bufadr);
  300. }
  301.  
  302. void inteua(unsigned char a1, unsigned char a2, cnr *cp)
  303. {
  304. register unsigned char skip, nofmt;
  305. register short endadr, addr, prot;
  306.  
  307. endadr = cvtadr(a1, a2, cp);
  308. addr = cp->bufadr;            /* find previous attribute */
  309. nofmt = 0;
  310. while (!((cp->atrbuff)[addr] & 0x8000)) {
  311.     if (addr == 0) {
  312.         nofmt = 1;
  313.         break;
  314.         }
  315.     else addr--;
  316.     }
  317. if (nofmt) prot = 0;
  318. else prot = (cp->atrbuff)[addr] & 0x2000;
  319. skip = 0;
  320. do {
  321.     if ((cp->atrbuff)[cp->bufadr] & 0x8000) {
  322.         prot = (cp->atrbuff)[cp->bufadr] & 0x2000;
  323.         skip = 1;
  324.         }
  325.     else if (!prot) {
  326.         if (skip) {
  327.             skip = 0;
  328.             }
  329.         setnull(cp);
  330.         }
  331.          else skip = 1;
  332.     if (skip) {
  333.         cp->bufadr++;
  334.         if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  335.         }
  336.     } while (endadr != cp->bufadr);
  337. }
  338.  
  339. void intsfe(unsigned char *field, unsigned char pairs, cnr *cp)
  340. {
  341. (cp->atrbuff)[cp->bufadr] = intpairs(0x8000, field, pairs, cp);
  342. (cp->chrbuff)[cp->bufadr] = 0x1d;
  343. cp->attrloc = cp->bufadr;
  344. cp->bufadr++;
  345. if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  346. cp->fmtscrn = 1;
  347. }
  348.  
  349. void intmf(unsigned char *field, unsigned char pairs, cnr *cp)
  350. {
  351. register short atr;
  352.  
  353. atr = intpairs((cp->atrbuff)[cp->bufadr], field, pairs, cp);
  354. if (atr & 0x8000) {
  355.     (cp->atrbuff)[cp->bufadr] = atr;
  356.     (cp->chrbuff)[cp->bufadr] = 0x1d;
  357.     }
  358. cp->bufadr++;
  359. if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  360. }
  361.  
  362. void intsa(unsigned char type, unsigned char value, cnr *cp)
  363. {
  364. register unsigned char safield[2];
  365.  
  366. if ((type == 0) && (value == 0)) {
  367.     cp->chratr = 0;
  368.     return;
  369.     }
  370. safield[0] = type;
  371. safield[1] = value;
  372. cp->chratr = intpairs(cp->chratr, safield, 1, cp);
  373. }
  374.  
  375. unsigned short intpairs(unsigned short atr, unsigned char *field,
  376.               unsigned char pairs, cnr *cp)
  377. {
  378. register unsigned char c;
  379. register short offset;
  380.  
  381. offset = 0;
  382. while (pairs > 0) {
  383.     c = field[offset+1];
  384.     switch(field[offset]) {
  385.  
  386.     case 0xC0:    atr &= 0xC0FF;
  387.             atr += (c & 0x3f) << 8;
  388.             break;
  389.  
  390.     case 0x41:    atr &= 0xFFE7;
  391.             if (c ==  0xF4) c = 0xF3;
  392.             atr += (c & 0x03) << 3;
  393.             break;
  394.  
  395.     case 0x42:    atr &= 0xFFF8;
  396.             if ((c & 0x07) == 0) break;
  397.             /* if (c == 0) c = 0xF4; */
  398.             atr += c & 0x07;
  399.             cp->colorfield = 1;
  400.             break;
  401.     case 0x43:    atr &= 0xFF3F;
  402.             atr += (c & 0x03) << 6;
  403.             break;
  404.     default:    break;
  405.     }
  406.     offset += 2;
  407.     pairs--;
  408.     }
  409. return(atr);
  410. }
  411.  
  412. void intdata(unsigned char code, unsigned char geflag, cnr *cp)
  413. { 
  414. (cp->chrbuff)[cp->bufadr] = code;
  415. (cp->atrbuff)[cp->bufadr] = cp->chratr;
  416. if ((code == 0xad) || (code == 0xbd))
  417.     if (cp->fixbracket) geflag = 1;
  418. if (geflag) (cp->atrbuff)[cp->bufadr] += 0x4000;
  419. cp->bufadr++;
  420. if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  421. }
  422.  
  423. void setnull(cnr *cp)
  424. {
  425. (cp->chrbuff)[cp->bufadr] = 0;
  426. (cp->atrbuff)[cp->bufadr] = 0;
  427. cp->bufadr++;
  428. if (cp->bufadr == cp->maxcnt) cp->bufadr = 0;
  429. }
  430.  
  431. short cvtadr(unsigned char a1, unsigned char a2, cnr *cp)
  432. {
  433. short a;
  434.  
  435. if ((a1 & 0xc0) == 0)        /* 14-bit address */
  436.     a = (a1 << 8) + a2;
  437. else a = ((a1 & 0x3f) << 6) + (a2 & 0x3f);    /* 12-bit address */
  438. if (a < 0) a = 0;
  439. if (a > cp->maxoff) a = cp->maxoff;
  440. return(a);
  441. }
  442.  
  443. void orderinit(void)
  444. {
  445. register short i, j;
  446. static unsigned char ordercodes[] =
  447.     {0x1d, 0x11, 0x13, 0x05, 0x3c, 0x12, 0x08, 0x29, 0x2c, 0x28, 0x00};
  448.  
  449. for (i=0; i < 256; i++) ordertab[i] = 0xff;
  450. j = strlen(ordercodes);
  451. for (i=0; i < j; i++) ordertab[ordercodes[i]] = 0;
  452. }
  453.  
  454. void setrectsel(short offset1, short offset2, cnr *cp)
  455. {
  456. short rowmin, rowmax, colmin, colmax, t;
  457. register short row, col;
  458.  
  459. if (offset1 == offset2) return;
  460. rowmin = offset1 / cp->scrhsize;
  461. colmin = offset1 % cp->scrhsize;
  462. rowmax = offset2 / cp->scrhsize;
  463. colmax = offset2 % cp->scrhsize;
  464. if (rowmin > rowmax) {
  465.     t = rowmax;
  466.     rowmax = rowmin;
  467.     rowmin = t;
  468.     }
  469. if (colmin > colmax) {
  470.     t = colmax;
  471.     colmax = colmin;
  472.     colmin = t;
  473.     }
  474. for (row = rowmin; row <= rowmax; row++)
  475.     for (col = colmin; col <= colmax; col++) {
  476.         if ((cp->atrbuff)[cp->scrhsize*row + col] ^= 0x0020) cp->textsel = 1;
  477.         }
  478. invldscr(cp);
  479. }
  480.  
  481. void settextsel(short offset1, short offset2, char invert, cnr *cp)
  482. {
  483. short start, end, offset;
  484.  
  485. start = offset1;
  486. end = offset2;
  487. if (end < start) {
  488.     start = offset2;
  489.     end = offset1;
  490.     }
  491. for (offset = start; offset < end; offset++) {
  492.     if (invert) {
  493.         (cp->atrbuff)[offset] ^= 0x0020;
  494.         }
  495.     else {
  496.         (cp->atrbuff)[offset] |= 0x0020;
  497.         }
  498.     cp->textsel = 1;
  499.     }
  500. invldscr(cp);
  501. }
  502.  
  503. void addfieldsel(cnr *cp)     /* select entire field for any field partly selected */
  504. {
  505. register short i;
  506. short firstpos, attrpos;
  507. char selflag;
  508.  
  509. if (!(cp->fmtscrn)) return;
  510.  
  511. firstpos = 0;
  512. /* if first byte not an attribute, find attribute for first byte */
  513. if (((cp->atrbuff)[0] & 0x8000) == 0) {
  514.     firstpos = -1;
  515.     for (i = cp->maxoff; i > 0; i--)
  516.         if ((cp->atrbuff)[i] & 0x8000) {
  517.             firstpos = i;
  518.             break;
  519.             }
  520.     }
  521. if (firstpos < 0) return;
  522.  
  523. /* set selection bit for the attribute byte of each field to be selected */
  524. attrpos = firstpos;
  525. for (i=0; i < cp->maxcnt; i++)
  526.     if ((cp->atrbuff)[i] & 0x8000) {        /* attribute byte */
  527.         attrpos = i;
  528.         }
  529.     else {                            /* data byte */
  530.         if ((cp->atrbuff)[i] & 0x0020) (cp->atrbuff)[attrpos] |= 0x0020;
  531.         }
  532.  
  533. /* set selections bits for all bytes in selected fields */
  534. selflag = ((cp->atrbuff)[firstpos] & 0x0020) == 0x0020;
  535. for (i=0; i < cp->maxcnt; i++)
  536.     if ((cp->atrbuff)[i] & 0x8000) {        /* attribute byte */
  537.         selflag = ((cp->atrbuff)[i] & 0x0020) == 0x0020;
  538.         }
  539.     else {
  540.         if (selflag) (cp->atrbuff)[i] |= 0x0020;
  541.         }
  542.  
  543. /* reset selection bits in the field attributes */
  544. for (i=0; i < cp->maxcnt; i++)
  545.     if ((cp->atrbuff)[i] & 0x8000) (cp->atrbuff)[i] &= 0xffdf;
  546. }
  547.  
  548. void resetsel(cnr *cp)
  549. {
  550. register short i;
  551. char selflag;
  552.  
  553. selflag = 0;
  554. for (i = 0; i < cp->maxcnt; i++) {
  555.     if ((cp->atrbuff)[i] & 0x0020) {
  556.         selflag = 1;
  557.         (cp->atrbuff)[i] &= 0xffdf;
  558.         }
  559.     }
  560. cp->textsel = 0;
  561. if (selflag) invldscr(cp);
  562. }
  563.  
  564. void checksel(cnr *cp)        /* check if there really is selected text */
  565. {
  566. register short i;
  567.  
  568. cp->textsel = 0;
  569. for (i=0; i < cp->maxcnt; i++) {
  570.     if ((cp->atrbuff)[i] & 0x0020) {
  571.         cp->textsel = 1;
  572.         return;
  573.         }
  574.     }
  575. }
  576.  
  577.                     /* find new starting point for extending text selection */
  578. void addsel(short *downloc, cnr *cp)
  579. {
  580. short startoff, endoff;
  581. register short i;
  582.  
  583. for (i=0; i < cp->maxcnt; i++)            /* get first selection offset */
  584.     if ((cp->atrbuff)[i] & 0x0020) {
  585.         startoff = i;
  586.         break;        
  587.         }
  588. for (i=cp->maxoff; i >= 0; i--)
  589.     if ((cp->atrbuff)[i] & 0x0020) {
  590.         endoff = i;
  591.         break;
  592.         }
  593. if ((*downloc) < startoff)
  594.      (*downloc) = endoff + 1;
  595. else (*downloc) = startoff;
  596. }
  597.  
  598. void wordadj(short *loc1, short *loc2, char endadj, cnr *cp)
  599. {
  600. short startloc, endloc;
  601. short startline, endline;
  602. char swapped;
  603.  
  604. swapped = 0;
  605. startloc = *loc1;
  606. endloc = *loc2;
  607. if (startloc > endloc) {
  608.     startloc = *loc2;
  609.     endloc = *loc1;
  610.     swapped = 1;
  611.     }
  612. endloc -= endadj;
  613. if (endloc < 0) return;
  614.  
  615. startline = startloc/cp->scrhsize;
  616. endline = endloc/cp->scrhsize;
  617. while ((!atspace(startloc, cp)) && (startloc > 0) &&
  618.        ((startloc-1)/cp->scrhsize == startline)) startloc--;
  619. while ((atspace(startloc, cp)) && (startloc < endloc) &&
  620.        ((startloc+1)/cp->scrhsize <= endline)) startloc++;
  621. while ((!atspace(endloc, cp)) && (endloc < cp->maxoff) &&
  622.        ((endloc+1)/cp->scrhsize == endline)) endloc++;
  623. while ((atspace(endloc, cp)) && (endloc > startloc) &&
  624.        ((endloc-1)/cp->scrhsize >= startline)) endloc--;
  625. if (atspace(startloc, cp) && atspace(endloc, cp)) return;
  626.  
  627. endloc += endadj;
  628.  
  629. if (swapped) {
  630.     *loc2 = startloc;
  631.     *loc1 = endloc;
  632.     }
  633. else {
  634.     *loc1 = startloc;
  635.     *loc2 = endloc;
  636.     }
  637. }
  638.  
  639. short atspace(short loc, cnr *cp)
  640. {
  641. if ((cp->chrbuff)[loc] == 0x40) return(1);
  642. if ((cp->chrbuff)[loc] == 0x00) return(1);
  643. if ((cp->atrbuff)[loc] & 0x8000) return(1);
  644. return(0);
  645. }
  646.